home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok24.lha / DME / SRC / source.zoo / menu.c < prev    next >
C/C++ Source or Header  |  1989-07-03  |  6KB  |  279 lines
  1.  
  2. /*
  3.  *  MENU.C
  4.  *
  5.  *  Menu routines... made to take up as little space as possible, and
  6.  *  thus uses many tricks which you should watch out for.
  7.  */
  8.  
  9. #include "defs.h"
  10.  
  11. typedef struct {
  12.     ITEM item;
  13.     char *com;
  14. } XITEM;
  15.  
  16. short Menuoff;
  17. short DoMenuoff;
  18.  
  19. MENU *Menu;
  20.  
  21. menu_strip(win)
  22. WIN *win;
  23. {
  24.     if (!Menuoff && Menu) {
  25.         SetMenuStrip(win,Menu);
  26.         Forbid();
  27.         win->Flags &= ~RMBTRAP;
  28.         Permit();
  29.     }
  30. }
  31.  
  32. menu_off()
  33. {
  34.     register ED *ed;
  35.     if (Menuoff == 0) {
  36.         for (ed = (ED *)DBase.mlh_Head; ed->Node.mln_Succ; ed = (ED *)ed->Node.mln_Succ) {
  37.             ClearMenuStrip(ed->Win);
  38.             Forbid();
  39.             ed->Win->Flags |= RMBTRAP;
  40.             Permit();
  41.         }
  42.     }
  43.     ++Menuoff;
  44. }
  45.  
  46. menu_on()
  47. {
  48.     register ED *ed;
  49.     if (Menu && Menuoff == 1) {
  50.         fixmenu();
  51.         for (ed = (ED *)DBase.mlh_Head; ed->Node.mln_Succ; ed = (ED *)ed->Node.mln_Succ) {
  52.             SetMenuStrip(ed->Win,Menu);
  53.             Forbid();
  54.             ed->Win->Flags &= ~RMBTRAP;
  55.             Permit();
  56.         }
  57.     }
  58.     --Menuoff;
  59. }
  60.  
  61. do_menuoff()
  62. {
  63.     menu_off();
  64.     ++DoMenuoff;
  65. }
  66.  
  67. do_menuon()
  68. {
  69.     if (DoMenuoff) {
  70.         --DoMenuoff;
  71.         menu_on();
  72.     }
  73. }
  74.  
  75. char *
  76. menutomacro(str)
  77. char *str;
  78. {
  79.     char header[64];
  80.     char itembuf[64];
  81.     register short i;
  82.     register char *ptr;
  83.     register MENU *menu;
  84.     register ITEM *item;
  85.  
  86.     for (i = 0; str[i] && str[i] != '-'; ++i);
  87.     if (str[i] == '-') {
  88.         strncpy(header, str, i);
  89.         header[i] = 0;
  90.         strcpy(itembuf, str + i + 1);
  91.         for (menu = Menu; menu; menu = menu->NextMenu) {
  92.             if (ncstrcmp(header, menu->MenuName) == 0) {
  93.                 for (item = menu->FirstItem; item; item = item->NextItem) {
  94.                     ptr = (char *)((ITEXT *)item->ItemFill)->IText;
  95.                     if (ncstrcmp(itembuf, ptr) == 0) {
  96.                         ptr = ((XITEM *)item)->com;
  97.                         goto done;
  98.                     }
  99.                 }
  100.             }
  101.         }
  102.     }
  103.     ptr = NULL;
  104. done:
  105.     return(ptr);
  106. }
  107.  
  108. char *
  109. menu_cmd(im)
  110. IMESS *im;
  111. {
  112.     XITEM *item;
  113.     char *ptr;
  114.  
  115.     if (item = (XITEM *)ItemAddress(Menu, im->Code))
  116.         return(item->com);
  117.     return(NULL);
  118. }
  119.  
  120. fixmenu()
  121. {
  122.     register MENU *menu;
  123.     register ITEM *item;
  124.     register ITEXT *it;
  125.     register int row, col, maxc, scr;
  126.  
  127.     col = 0;
  128.     for (menu = Menu; menu; menu = menu->NextMenu) {
  129.         maxc = strlen(menu->MenuName);
  130.         row = 0;
  131.         for (item = menu->FirstItem; item; item = item->NextItem) {
  132.             it = (ITEXT *)item->ItemFill;
  133.             item->TopEdge = row;
  134.             scr = strlen(((ITEXT *)item->ItemFill)->IText);
  135.             if (scr > maxc)
  136.                 maxc = scr;
  137.             item->Height = 10;
  138.             row += item->Height;
  139.         }
  140.         maxc = (maxc * 8);
  141.         for (item = menu->FirstItem; item; item = item->NextItem)
  142.             item->Width = maxc;
  143.         menu->Width = strlen(menu->MenuName)*8+24;
  144.         menu->LeftEdge = col;
  145.         menu->Height = row;
  146.         col += menu->Width;
  147.     }
  148. }
  149.  
  150. /*
  151.  *  menuclear
  152.  *  menuadd     header  item    command
  153.  *  menudel     header  item
  154.  *  menudelhdr  header
  155.  */
  156.  
  157. do_menuclear()
  158. {
  159.     menu_off();
  160.     while (Menu) {
  161.         av[1] = (ubyte *)Menu->MenuName;
  162.         do_menudelhdr();
  163.     }
  164.     menu_on();
  165. }
  166.  
  167. do_menuadd()
  168. {
  169.     register MENU *menu, **mpr;
  170.     register ITEM *item, **ipr;
  171.     register ITEXT *it;
  172.  
  173.     menu_off();
  174.     mpr = &Menu;
  175.     for (menu = *mpr; menu; menu = *mpr) {
  176.         if (strcmp(av[1], menu->MenuName) == 0) {
  177.             ipr = &menu->FirstItem;
  178.             for (item = *ipr; item; item = *ipr) {
  179.                 if (strcmp(av[2], ((ITEXT *)item->ItemFill)->IText) == 0)
  180.                     goto newname;
  181.                 ipr = &item->NextItem;
  182.             }
  183.             goto newitem;
  184.         }
  185.         mpr = &menu->NextMenu;
  186.     }
  187. newmenu:    /*  create new menu */
  188.     menu = malloc(sizeof(MENU));
  189.     bzero(menu, sizeof(MENU));
  190.     menu->NextMenu = *mpr;
  191.     *mpr = menu;
  192.     menu->Flags = MENUENABLED;
  193.     menu->MenuName = malloc(strlen(av[1])+1);
  194.     strcpy(menu->MenuName, av[1]);
  195.     ipr = &menu->FirstItem;
  196.     *ipr = NULL;
  197. newitem:    /*  create new item */
  198.     it = malloc(sizeof(ITEXT));
  199.     bzero(it, sizeof(ITEXT));
  200.     it->BackPen = 1;
  201.     it->DrawMode = JAM2;
  202.     it->IText = malloc(strlen(av[2])+1);
  203.     strcpy(it->IText, av[2]);
  204.     item = malloc(sizeof(XITEM));
  205.     bzero(item, sizeof(XITEM));
  206.     item->NextItem = *ipr;
  207.     *ipr = item;
  208.     item->ItemFill = (APTR)it;
  209.     item->Flags = ITEMTEXT|ITEMENABLED|HIGHCOMP;
  210. newname:    /*  create new name */
  211.     if (((XITEM *)item)->com)
  212.         free(((XITEM *)item)->com);
  213.     ((XITEM *)item)->com = malloc(strlen(av[3])+1);
  214.     strcpy(((XITEM *)item)->com, av[3]);
  215.     menu_on();
  216. }
  217.  
  218. do_menudelhdr()
  219. {
  220.     register MENU *menu;
  221.     register MENU **mpr;
  222.  
  223.     menu_off();
  224.     mpr = &Menu;
  225.     for (menu = *mpr; menu; menu = *mpr) {
  226.         if (strcmp(av[1], menu->MenuName) == 0) {
  227.             if (menu->FirstItem) {
  228.                 while (menu->FirstItem) {
  229.                     av[2] = ((ITEXT *)menu->FirstItem->ItemFill)->IText;
  230.                     if (do_menudel())
  231.                         break;
  232.                 }
  233.                 break;
  234.             }
  235.             *mpr = menu->NextMenu;
  236.             free(menu->MenuName);
  237.             free(menu);
  238.             break;
  239.         }
  240.         mpr = &menu->NextMenu;
  241.     }
  242.     menu_on();
  243. }
  244.  
  245. do_menudel()
  246. {
  247.     register MENU *menu;
  248.     register ITEM *item, **ipr;
  249.     register ITEXT *it;
  250.     short ret = 0;
  251.  
  252.     menu_off();
  253.     for (menu = Menu; menu; menu = menu->NextMenu) {
  254.         if (strcmp(av[1], menu->MenuName) == 0) {
  255.             ipr = &menu->FirstItem;
  256.             for (item = *ipr; item; item = *ipr) {
  257.                 it = (ITEXT *)item->ItemFill;
  258.                 if (strcmp(av[2], it->IText) == 0) {
  259.                     *ipr = item->NextItem;
  260.                     free(it->IText);
  261.                     free(it);
  262.                     free(((XITEM *)item)->com);
  263.                     free(item);
  264.                     if (!menu->FirstItem) {
  265.                         do_menudelhdr();
  266.                         ret = 1;
  267.                     }
  268.                     menu_on();
  269.                     return(ret);
  270.                 }
  271.                 ipr = &item->NextItem;
  272.             }
  273.         }
  274.     }
  275.     menu_on();
  276.     return(ret);
  277. }
  278.  
  279.